home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / multiprocessing / process.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  9KB  |  285 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. __all__ = [
  5.     'Process',
  6.     'current_process',
  7.     'active_children']
  8. import os
  9. import sys
  10. import signal
  11. import itertools
  12.  
  13. try:
  14.     ORIGINAL_DIR = os.path.abspath(os.getcwd())
  15. except OSError:
  16.     ORIGINAL_DIR = None
  17.  
  18.  
  19. def current_process():
  20.     '''
  21.     Return process object representing the current process
  22.     '''
  23.     return _current_process
  24.  
  25.  
  26. def active_children():
  27.     '''
  28.     Return list of process objects corresponding to live child processes
  29.     '''
  30.     _cleanup()
  31.     return list(_current_process._children)
  32.  
  33.  
  34. def _cleanup():
  35.     for p in list(_current_process._children):
  36.         if p._popen.poll() is not None:
  37.             _current_process._children.discard(p)
  38.             continue
  39.  
  40.  
  41. class Process(object):
  42.     '''
  43.     Process objects represent activity that is run in a separate process
  44.  
  45.     The class is analagous to `threading.Thread`
  46.     '''
  47.     _Popen = None
  48.     
  49.     def __init__(self, group = None, target = None, name = None, args = (), kwargs = { }):
  50.         if not group is None:
  51.             raise AssertionError('group argument must be None for now')
  52.         count = None._counter.next()
  53.         self._identity = _current_process._identity + (count,)
  54.         self._authkey = _current_process._authkey
  55.         self._daemonic = _current_process._daemonic
  56.         self._tempdir = _current_process._tempdir
  57.         self._parent_pid = os.getpid()
  58.         self._popen = None
  59.         self._target = target
  60.         self._args = tuple(args)
  61.         self._kwargs = dict(kwargs)
  62.         if not name:
  63.             pass
  64.         self._name = type(self).__name__ + '-' + ':'.join((lambda .0: pass)(self._identity))
  65.  
  66.     
  67.     def run(self):
  68.         '''
  69.         Method to be run in sub-process; can be overridden in sub-class
  70.         '''
  71.         if self._target:
  72.             self._target(*self._args, **self._kwargs)
  73.  
  74.     
  75.     def start(self):
  76.         '''
  77.         Start child process
  78.         '''
  79.         if not self._popen is None:
  80.             raise AssertionError('cannot start a process twice')
  81.         if not None._parent_pid == os.getpid():
  82.             raise AssertionError('can only start a process object created by current process')
  83.         if not not (None._daemonic):
  84.             raise AssertionError('daemonic processes are not allowed to have children')
  85.         None()
  86.         if self._Popen is not None:
  87.             Popen = self._Popen
  88.         else:
  89.             Popen = Popen
  90.             import forking
  91.         self._popen = Popen(self)
  92.         _current_process._children.add(self)
  93.  
  94.     
  95.     def terminate(self):
  96.         '''
  97.         Terminate process; sends SIGTERM signal or uses TerminateProcess()
  98.         '''
  99.         self._popen.terminate()
  100.  
  101.     
  102.     def join(self, timeout = None):
  103.         '''
  104.         Wait until child process terminates
  105.         '''
  106.         if not self._parent_pid == os.getpid():
  107.             raise AssertionError('can only join a child process')
  108.         if not None._popen is not None:
  109.             raise AssertionError('can only join a started process')
  110.         res = None._popen.wait(timeout)
  111.         if res is not None:
  112.             _current_process._children.discard(self)
  113.  
  114.     
  115.     def is_alive(self):
  116.         '''
  117.         Return whether process is alive
  118.         '''
  119.         if self is _current_process:
  120.             return True
  121.         if not None._parent_pid == os.getpid():
  122.             raise AssertionError('can only test a child process')
  123.         if None._popen is None:
  124.             return False
  125.         None._popen.poll()
  126.         return self._popen.returncode is None
  127.  
  128.     
  129.     def name(self):
  130.         return self._name
  131.  
  132.     name = property(name)
  133.     
  134.     def name(self, name):
  135.         if not isinstance(name, basestring):
  136.             raise AssertionError('name must be a string')
  137.         self._name = None
  138.  
  139.     name = name.setter(name)
  140.     
  141.     def daemon(self):
  142.         '''
  143.         Return whether process is a daemon
  144.         '''
  145.         return self._daemonic
  146.  
  147.     daemon = property(daemon)
  148.     
  149.     def daemon(self, daemonic):
  150.         '''
  151.         Set whether process is a daemon
  152.         '''
  153.         if not self._popen is None:
  154.             raise AssertionError('process has already started')
  155.         self._daemonic = None
  156.  
  157.     daemon = daemon.setter(daemon)
  158.     
  159.     def authkey(self):
  160.         return self._authkey
  161.  
  162.     authkey = property(authkey)
  163.     
  164.     def authkey(self, authkey):
  165.         '''
  166.         Set authorization key of process
  167.         '''
  168.         self._authkey = AuthenticationString(authkey)
  169.  
  170.     authkey = authkey.setter(authkey)
  171.     
  172.     def exitcode(self):
  173.         '''
  174.         Return exit code of process or `None` if it has yet to stop
  175.         '''
  176.         if self._popen is None:
  177.             return self._popen
  178.         return None._popen.poll()
  179.  
  180.     exitcode = property(exitcode)
  181.     
  182.     def ident(self):
  183.         '''
  184.         Return identifier (PID) of process or `None` if it has yet to start
  185.         '''
  186.         return None if self is _current_process else self._popen.pid
  187.  
  188.     ident = property(ident)
  189.     pid = ident
  190.     
  191.     def __repr__(self):
  192.         if self is _current_process:
  193.             status = 'started'
  194.         elif self._parent_pid != os.getpid():
  195.             status = 'unknown'
  196.         elif self._popen is None:
  197.             status = 'initial'
  198.         elif self._popen.poll() is not None:
  199.             status = self.exitcode
  200.         else:
  201.             status = 'started'
  202.         return None % ('<%s(%s, %s%s)>', type(self).__name__, self._name, status if type(status) is int else '')
  203.  
  204.     
  205.     def _bootstrap(self):
  206.         global _current_process
  207.         util = util
  208.         import 
  209.         
  210.         try:
  211.             self._children = set()
  212.             self._counter = itertools.count(1)
  213.             
  214.             try:
  215.                 sys.stdin.close()
  216.                 sys.stdin = open(os.devnull)
  217.             except (OSError, ValueError):
  218.                 pass
  219.  
  220.             _current_process = self
  221.             util._finalizer_registry.clear()
  222.             util._run_after_forkers()
  223.             util.info('child process calling self.run()')
  224.             
  225.             try:
  226.                 self.run()
  227.                 exitcode = 0
  228.             finally:
  229.                 util._exit_function()
  230.  
  231.         except SystemExit:
  232.             e = None
  233.             if not e.args:
  234.                 exitcode = 1
  235.             elif isinstance(e.args[0], int):
  236.                 exitcode = e.args[0]
  237.             else:
  238.                 sys.stderr.write(str(e.args[0]) + '\n')
  239.                 sys.stderr.flush()
  240.                 exitcode = 0 if isinstance(e.args[0], str) else 1
  241.         except:
  242.             exitcode = 1
  243.             import traceback as traceback
  244.             sys.stderr.write('Process %s:\n' % self.name)
  245.             sys.stderr.flush()
  246.             traceback.print_exc()
  247.  
  248.         util.info('process exiting with exitcode %d' % exitcode)
  249.         return exitcode
  250.  
  251.  
  252.  
  253. class AuthenticationString(bytes):
  254.     
  255.     def __reduce__(self):
  256.         Popen = Popen
  257.         import forking
  258.         if not Popen.thread_is_spawning():
  259.             raise TypeError('Pickling an AuthenticationString object is disallowed for security reasons')
  260.         return (AuthenticationString, (bytes(self),))
  261.  
  262.  
  263.  
  264. class _MainProcess(Process):
  265.     
  266.     def __init__(self):
  267.         self._identity = ()
  268.         self._daemonic = False
  269.         self._name = 'MainProcess'
  270.         self._parent_pid = None
  271.         self._popen = None
  272.         self._counter = itertools.count(1)
  273.         self._children = set()
  274.         self._authkey = AuthenticationString(os.urandom(32))
  275.         self._tempdir = None
  276.  
  277.  
  278. _current_process = _MainProcess()
  279. del _MainProcess
  280. _exitcode_to_name = { }
  281. for name, signum in signal.__dict__.items():
  282.     if name[:3] == 'SIG' and '_' not in name:
  283.         _exitcode_to_name[-signum] = name
  284.         continue
  285.